package com.weai.controller;

import com.weai.dto.ApiResponse;
import com.weai.dto.TaskDTO;
import com.weai.dto.TaskQueryDTO;
import com.weai.service.TaskService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * 任务控制器
 */
@RestController
@RequestMapping("/api/tasks")
@Tag(name = "任务管理", description = "任务相关操作接口")
@RequiredArgsConstructor
@Slf4j
public class TaskController {
    
    private final TaskService taskService;
    
    /**
     * 创建任务
     *
     * @param taskDTO 任务信息
     * @return 创建后的任务信息
     */
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    @Operation(summary = "创建任务", description = "创建一个新任务")
    public ApiResponse<TaskDTO> createTask(@Valid @RequestBody TaskDTO taskDTO) {
        log.info("接收到创建任务请求");
        TaskDTO createdTask = taskService.createTask(taskDTO);
        return ApiResponse.success("任务创建成功", createdTask);
    }
    
    /**
     * 更新任务
     *
     * @param id 任务ID
     * @param taskDTO 任务信息
     * @return 更新后的任务信息
     */
    @PutMapping("/{id}")
    @Operation(summary = "更新任务", description = "根据ID更新任务信息")
    public ApiResponse<TaskDTO> updateTask(
            @Parameter(description = "任务ID", required = true) @PathVariable Integer id,
            @Valid @RequestBody TaskDTO taskDTO) {
        log.info("接收到更新任务请求, ID: {}", id);
        TaskDTO updatedTask = taskService.updateTask(id, taskDTO);
        return ApiResponse.success("任务更新成功", updatedTask);
    }
    
    /**
     * 更新任务状态
     *
     * @param id 任务ID
     * @param status 任务状态
     * @param updater 修改人
     * @return 更新后的任务信息
     */
    @PatchMapping("/{id}/status")
    @Operation(summary = "更新任务状态", description = "根据ID更新任务状态")
    public ApiResponse<TaskDTO> updateTaskStatus(
            @Parameter(description = "任务ID", required = true) @PathVariable Integer id,
            @Parameter(description = "任务状态", required = true) @RequestParam String status,
            @Parameter(description = "修改人", required = false) @RequestParam(required = false) String updater) {
        log.info("接收到更新任务状态请求, ID: {}, 状态: {}, 修改人: {}", id, status, updater);
        
        // 构建任务DTO，包含修改人信息
        TaskDTO taskDTO = TaskDTO.builder()
                .status(status)
                .updater(updater)
                .build();
        
        TaskDTO updatedTask = taskService.updateTask(id, taskDTO);
        return ApiResponse.success("任务状态更新成功", updatedTask);
    }
    
    /**
     * 根据ID查询任务
     *
     * @param id 任务ID
     * @return 任务信息
     */
    @GetMapping("/{id}")
    @Operation(summary = "根据ID查询任务", description = "根据ID获取任务详细信息")
    public ApiResponse<TaskDTO> getTaskById(
            @Parameter(description = "任务ID", required = true) @PathVariable Integer id) {
        log.info("接收到根据ID查询任务请求, ID: {}", id);
        TaskDTO task = taskService.findById(id);
        return ApiResponse.success("查询成功", task);
    }
    
    /**
     * 删除任务
     *
     * @param id 任务ID
     * @return 操作结果
     */
    @DeleteMapping("/{id}")
    @Operation(summary = "删除任务", description = "根据ID删除任务")
    public ApiResponse<Void> deleteTask(
            @Parameter(description = "任务ID", required = true) @PathVariable Integer id) {
        log.info("接收到删除任务请求, ID: {}", id);
        taskService.deleteById(id);
        return ApiResponse.success("任务删除成功", null);
    }
    
    /**
     * 查询任务列表
     *
     * @param title 任务标题（模糊查询）
     * @param creater 任务创建人
     * @param receiver 任务处理人
     * @param type 需求类型
     * @param subTypes 子类型（多选）
     * @param isMyTask 是否查询当前用户的任务
     * @param currentUser 当前用户
     * @return 按状态分组的任务列表
     */
    @GetMapping("/search")
    @Operation(summary = "查询任务列表", description = "根据条件查询任务列表，并按状态分组")
    public ApiResponse<Map<String, List<TaskDTO>>> searchTasks(
            @Parameter(description = "任务标题（模糊查询）") @RequestParam(required = false) String title,
            @Parameter(description = "任务创建人") @RequestParam(required = false) String creater,
            @Parameter(description = "任务处理人") @RequestParam(required = false) String receiver,
            @Parameter(description = "需求类型") @RequestParam(required = false) String type,
            @Parameter(description = "子类型（多选）") @RequestParam(required = false) List<String> subTypes,
            @Parameter(description = "是否查询当前用户的任务") @RequestParam(required = false) Boolean isMyTask,
            @Parameter(description = "当前用户") @RequestParam(required = false) String currentUser) {
        
        // 构建查询DTO
        TaskQueryDTO queryDTO = TaskQueryDTO.builder()
                .title(title)
                .creater(creater)
                .receiver(receiver)
                .type(type)
                .subTypes(subTypes)
                .isMyTask(isMyTask)
                .currentUser(currentUser)
                .build();
        
        log.info("接收到查询任务列表请求, 条件: {}", queryDTO);
        Map<String, List<TaskDTO>> tasks = taskService.findAllGroupByStatus(queryDTO);
        return ApiResponse.success("查询成功", tasks);
    }
    
    /**
     * 查询当前用户的任务
     *
     * @param username 用户名
     * @return 按状态分组的任务列表
     */
    @GetMapping("/my-tasks")
    @Operation(summary = "查询当前用户的任务", description = "查询当前用户创建或处理的任务")
    public ApiResponse<Map<String, List<TaskDTO>>> getMyTasks(
            @Parameter(description = "用户名", required = true) @RequestParam String username) {
        log.info("接收到查询用户 {} 的任务请求", username);
        Map<String, List<TaskDTO>> tasks = taskService.findMyTasks(username);
        return ApiResponse.success("查询成功", tasks);
    }
    
    /**
     * 根据titleIndex查询任务
     *
     * @param titleIndex 任务唯一标识
     * @return 任务详情
     */
    @GetMapping("/by-title-index/{titleIndex}")
    @Operation(summary = "根据titleIndex查询任务", description = "根据任务唯一标识获取任务详情")
    public ApiResponse<TaskDTO> getTaskByTitleIndex(
            @Parameter(description = "任务唯一标识", required = true) @PathVariable String titleIndex) {
        log.info("接收到根据titleIndex查询任务请求, titleIndex: {}", titleIndex);
        TaskDTO task = taskService.findByTitleIndex(titleIndex);
        if (task == null) {
            return ApiResponse.fail(404, "任务不存在");
        }
        return ApiResponse.success("查询成功", task);
    }
    
    /**
     * 查询子任务列表
     *
     * @param parentId 父任务ID
     * @return 子任务列表
     */
    @GetMapping("/child-tasks/{parentId}")
    @Operation(summary = "查询子任务列表", description = "根据父任务ID查询所有子任务")
    public ApiResponse<List<TaskDTO>> getChildTasks(
            @Parameter(description = "父任务ID", required = true) @PathVariable String parentId) {
        log.info("接收到查询子任务请求, parentId: {}", parentId);
        List<TaskDTO> childTasks = taskService.findChildTasks(parentId);
        return ApiResponse.success("查询成功", childTasks);
    }
} 